package com.ffggffgfv.backend.controller;

import com.ffggffgfv.backend.dto.*;
import com.ffggffgfv.backend.entity.Admin;
import com.ffggffgfv.backend.service.AdminService;
import com.ffggffgfv.backend.util.JWTUtil;
import com.ffggffgfv.backend.util.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * 管理员控制器
 */
@RestController
@RequestMapping("/api/admin")
public class AdminController {

    @Autowired
    private AdminService adminService;

    @Autowired
    private JWTUtil jwtUtil;

    /**
     * 管理员登录
     *
     * @param loginDTO 登录信息
     * @return 登录结果
     */
    @PostMapping("/login")
    public Result login(@RequestBody AdminLoginDTO loginDTO) {
        // 参数验证
        if (loginDTO.getUsername() == null || loginDTO.getUsername().trim().isEmpty()) {
            return Result.validateFailed("用户名不能为空");
        }
        if (loginDTO.getPassword() == null || loginDTO.getPassword().trim().isEmpty()) {
            return Result.validateFailed("密码不能为空");
        }

        // 执行登录
        Map<String, Object> loginResult = adminService.login(loginDTO);

        if (loginResult == null) {
            return Result.validateFailed("用户名或密码错误");
        }

        return Result.success(loginResult, "登录成功");
    }

    /**
     * 获取当前管理员信息
     *
     * @param token JWT令牌
     * @return 管理员信息
     */
    @GetMapping("/info")
    public Result getCurrentAdminInfo(@RequestHeader(value = "Authorization") String token) {
        // 从令牌中提取管理员ID
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                Long adminId = jwtUtil.extractUserId(token);
                AdminInfoDTO adminInfo = adminService.getAdminInfo(adminId);

                if (adminInfo == null) {
                    return Result.unauthorized("管理员不存在或已被禁用");
                }

                return Result.success(adminInfo, "获取管理员信息成功");

            } catch (Exception e) {
                return Result.unauthorized("无效的认证令牌");
            }
        }
        return Result.unauthorized("未提供认证令牌");
    }

    /**
     * 更新管理员信息
     *
     * @param updateDTO 更新信息
     * @param token     JWT令牌
     * @return 更新结果
     */
    @PutMapping("/info")
    public Result updateAdmin(@RequestBody AdminUpdateDTO updateDTO, @RequestHeader(value = "Authorization") String token) {
        // 从令牌中提取管理员ID
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                Long adminId = jwtUtil.extractUserId(token);

                // 更新信息
                Admin updatedAdmin = adminService.updateAdmin(adminId, updateDTO);

                if (updatedAdmin == null) {
                    return Result.validateFailed("更新失败，可能原密码错误或管理员不存在");
                }

                Map<String, Object> data = new HashMap<>();
                data.put("id", updatedAdmin.getId());
                data.put("username", updatedAdmin.getUsername());
                data.put("avatarUrl", updatedAdmin.getAvatarUrl());

                return Result.success(data, "信息更新成功");

            } catch (Exception e) {
                return Result.unauthorized("无效的认证令牌");
            }
        }
        return Result.unauthorized("未提供认证令牌");
    }

    /**
     * 获取管理员列表（分页）
     *
     * @param username 用户名（可选）
     * @param status   状态（可选）
     * @param pageNum  页码
     * @param pageSize 每页数量
     * @param token    JWT令牌
     * @return 管理员列表
     */
    @GetMapping("/list")
    public Result getAdmins(
            @RequestParam(required = false) String username,
            @RequestParam(required = false) Integer status,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestHeader(value = "Authorization") String token) {

        // 验证是否有超级管理员权限
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权访问");
        }

        PageResult<Admin> pageResult = adminService.findByPage(username, status, pageNum, pageSize);
        return Result.success(pageResult, "获取管理员列表成功");
    }

    /**
     * 创建管理员
     *
     * @param admin 管理员信息
     * @param token JWT令牌
     * @return 创建结果
     */
    @PostMapping
    public Result createAdmin(@RequestBody Admin admin, @RequestHeader(value = "Authorization") String token) {
        // 验证是否有超级管理员权限
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权创建管理员");
        }

        // 参数验证
        if (admin.getUsername() == null || admin.getUsername().trim().isEmpty()) {
            return Result.validateFailed("用户名不能为空");
        }
        if (admin.getPassword() == null || admin.getPassword().trim().isEmpty()) {
            return Result.validateFailed("密码不能为空");
        }

        // 检查用户名是否已存在
        if (adminService.isUsernameExists(admin.getUsername())) {
            return Result.conflict("用户名已存在");
        }

        // 创建管理员
        Admin createdAdmin = adminService.createAdmin(admin);

        Map<String, Object> data = new HashMap<>();
        data.put("id", createdAdmin.getId());
        data.put("username", createdAdmin.getUsername());

        return Result.success(data, "管理员创建成功");
    }

    /**
     * 更新管理员状态
     *
     * @param id     管理员ID
     * @param status 状态值
     * @param token  JWT令牌
     * @return 更新结果
     */
    @PutMapping("/{id}/status")
    public Result updateAdminStatus(
            @PathVariable Long id,
            @RequestParam Integer status,
            @RequestHeader(value = "Authorization") String token) {

        // 验证是否有超级管理员权限
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权修改管理员状态");
        }

        // 参数验证
        if (status == null || (status != 0 && status != 1)) {
            return Result.validateFailed("状态值无效");
        }

        // 更新状态
        boolean success = adminService.updateStatus(id, status);

        if (!success) {
            return Result.validateFailed("管理员不存在或状态更新失败");
        }

        return Result.success(null, "管理员状态已更新");
    }

    /**
     * 分配管理员角色
     *
     * @param id          管理员ID
     * @param userRoleDTO 角色ID列表
     * @param token       JWT令牌
     * @return 分配结果
     */
    @PostMapping("/{id}/roles")
    public Result assignRoles(
            @PathVariable Long id,
            @RequestBody UserRoleDTO userRoleDTO,
            @RequestHeader(value = "Authorization") String token) {

        // 验证是否有超级管理员权限
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权分配管理员角色");
        }

        // 查询管理员是否存在
        if (adminService.findById(id) == null) {
            return Result.validateFailed("管理员不存在");
        }

        // 分配角色
        boolean success = adminService.assignRoles(id, userRoleDTO);

        if (!success) {
            return Result.validateFailed("角色分配失败");
        }

        Map<String, Object> data = new HashMap<>();
        data.put("adminId", id);
        data.put("roleCount", userRoleDTO.getRoleIds() != null ? userRoleDTO.getRoleIds().size() : 0);

        return Result.success(data, "角色分配成功");
    }

    /**
     * 管理员注册（仅用于测试）
     * 在生产环境中应删除此方法
     *
     * @param registerDTO 注册信息
     * @return 注册结果
     */
    @PostMapping("/register")
    public Result register(@RequestBody AdminRegisterDTO registerDTO) {
        // 参数验证
        if (registerDTO.getUsername() == null || registerDTO.getUsername().trim().isEmpty()) {
            return Result.validateFailed("用户名不能为空");
        }

        if (registerDTO.getPassword() == null || registerDTO.getPassword().trim().isEmpty()) {
            return Result.validateFailed("密码不能为空");
        }
        
//        if (!registerDTO.getPassword().equals(registerDTO.getConfirmPassword())) {
//            return Result.validateFailed("两次输入密码不一致");
//        }
        
        // 检查用户名是否已存在
        if (adminService.isUsernameExists(registerDTO.getUsername())) {
            return Result.conflict("用户名已存在");
        }

        // 注册管理员
        try {
            Admin admin = adminService.register(registerDTO);

            Map<String, Object> data = new HashMap<>();
            data.put("id", admin.getId());
            data.put("username", admin.getUsername());
            data.put("avatarUrl", admin.getAvatarUrl());

            return Result.success(data, "管理员注册成功");
        } catch (Exception e) {
            return Result.failed("注册失败：" + e.getMessage());
        }
    }

    /**
     * 验证是否有超级管理员权限
     *
     * @param token JWT令牌
     * @return 是否有超级管理员权限
     */
    private boolean validateSuperAdminPermission(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                return jwtUtil.hasAdminRole(token);
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }
}
